पॉइंटर अंकगणित सी में

हम संकेत, घटाव, आदि जैसे बिंदुओं पर अंकगणितीय संचालन कर सकते हैं, हालांकि, जैसा कि हम जानते हैं कि पॉइंटर में पता होता है, पॉइंटर पर किए गए एक अंकगणितीय ऑपरेशन का परिणाम भी एक पॉइंटर होगा यदि अन्य ऑपरेंड टाइप इंटेगर का है। पॉइंटर-से-पॉइंटर घटाव में, परिणाम एक पूर्णांक मूल्य होगा। निम्नलिखित अंकगणितीय संचालन सी भाषा में सूचक पर संभव हैं: वेतन वृद्धि घटती जोड़ना घटाव तुलना

सी में पॉइंटर को बढ़ाना

यदि हम 1 तक एक पॉइंटर को बढ़ाते हैं, तो पॉइंटर तत्काल अगले स्थान की ओर इशारा करना शुरू कर देगा। यह सामान्य अंकगणित से कुछ अलग है क्योंकि सूचक का मूल्य उस डेटा प्रकार के आकार से बढ़ जाएगा, जिसमें सूचक इंगित कर रहा है। हम एक पॉइंटर पर वेतन वृद्धि संचालन का उपयोग करके एक सरणी को पार कर सकते हैं जो सरणी के हर तत्व की ओर इशारा करते रहेंगे, उस पर कुछ ऑपरेशन करेंगे, और एक लूप में खुद को अपडेट करेंगे। सूचक को बढ़ाने का नियम नीचे दिया गया है:

DmauRMkktamaee= vaaZmaanaRpataa + maIM * kaRAakar(deTa pzakar)

जहां मैं वह संख्या है जिसके द्वारा सूचक में वृद्धि होती है।

32-बिट

32-बिट इंट वैरिएबल के लिए, इसे 2 बाइट्स द्वारा बढ़ाया जाएगा।

64-बिट

64-बिट इंट वैरिएबल के लिए, इसे 4 बाइट्स द्वारा बढ़ाया जाएगा। आइए 64-बिट आर्किटेक्चर पर पॉइंटर वैरिएबल को बढ़ाने का उदाहरण देखें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF(){
paunaZ saMqyaa=50;
paunaZ *pai;//saucak kae paunaZ
pai=&saMqyaa;//BaMdar pataa ka saMqyaa car
mauDznama("pataa ka p car hI %u \n",pai);
pai=pai+1;
mauDznama("baaD vaetana vaoDi: pataa ka p car hI %u \n",pai); // maeM hmaara sYaitaiF, pai EcCa paanaa vaoDi vDara 4 baaET sa.
naivaZtanama 0;
}

आउटपुट

pataa ka pai car hI 3214864300
baaD vaetanaRvaoDi: pataa ka pai car hI 3214864304

पॉइंटर का उपयोग करके एक सरणी का पता लगाना

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
riKta mauqyaF ()
{
paunaZ Aagamana[5] = {1, 2, 3, 4, 5};
paunaZ *pai = Aagamana;
paunaZ maIM;
mauDznama("CpaaEZ sarnai tatvaaeM...\n");
kurftae(maIM = 0; maIM< 5; maIM++)
{
mauDznama("%paunaZ ",*(pai+maIM));
}
}

आउटपुट

CpaaEZ sarnai tatvaaeM...
1 2 3 4 5

सी में पॉइंटर को घटाना

वृद्धि की तरह, हम एक सूचक चर को घट सकते हैं। यदि हम एक सूचक को कम करते हैं, तो यह पिछले स्थान की ओर इशारा करना शुरू कर देगा। सूचक को घटाने का सूत्र नीचे दिया गया है:

DmauRMkktamaee= vaaZmaanaRpataa - maIM * kaRAakar(deTa pzakar)

32-बिट

32-बिट इंट चर के लिए, यह 2 बाइट्स द्वारा घटाया जाएगा।

64-बिट

64-बिट इंट चर के लिए, यह 4 बाइट्स द्वारा घटाया जाएगा। आइए 64-बिट ओएस पर पॉइंटर चर को घटाने का उदाहरण देखें।

उदाहरण

#samaahitaF <PsaTidiAayaAae.Pca>
riKta mauqyaF(){
paunaZ saMqyaa=50;
paunaZ *pai;//saucak kae paunaZ
pai=&saMqyaa;//BaMdar pataa ka saMqyaa car
mauDznama("pataa ka p car hI %u \n",pai);
pai=pai-1;
mauDznama("baaD oaTtai: pataa ka p car hI %u \n",pai); // pai EcCa Aba baiMDu kae taurMta pahlaeRka jagah.
}

आउटपुट

पी चर का पता 3214864300 है घटने के बाद: पी चर का पता 3214864296 है

हम पॉइंटर चर में एक मान जोड़ सकते हैं। पॉइंटर में मूल्य जोड़ने का सूत्र नीचे दिया गया है:

DmauRMkktamaee= vaaZmaanaRpataa + (saMqyaa * kaRAakar(deTa pzakar))

32-बिट

32-बिट इंट वैरिएबल के लिए, यह 2 * नंबर जोड़ देगा।

64-बिट

64-बिट इंट वैरिएबल के लिए, यह 4 * नंबर जोड़ देगा। आइए 64-बिट आर्किटेक्चर पर पॉइंटर चर में मूल्य जोड़ने का उदाहरण देखें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF(){
paunaZ saMqyaa=50;
paunaZ *pai;//saucak kae paunaZ
pai=&saMqyaa;//BaMdar pataa ka saMqyaa car
mauDznama("pataa ka p car hI %u \n",pai);
pai=pai+3; //jaaed.naa 3 kae saucak car
mauDznama("baaD jaaed.naa 3: pataa ka p car hI %u \n",pai);
naivaZtanama 0;
}

आउटपुट

pataa ka pai car hI 3214864300
baaD jaaed.naa 3: pataa ka pai car hI 3214864312

जैसा कि आप देख सकते हैं, P का पता 3214864300 है। लेकिन P चर के साथ 3 जोड़ने के बाद, यह 3214864312 है, अर्थात, 4*3 = 12 वेतन वृद्धि। चूंकि हम 64-बिट आर्किटेक्चर का उपयोग कर रहे हैं, यह 12 में वृद्धि करता है। लेकिन अगर हम 32-बिट आर्किटेक्चर का उपयोग कर रहे थे, तो यह केवल 6 तक बढ़ रहा था, अर्थात, 2*3 = 6। जैसा कि पूर्णांक मान 32-बिट ओएस में 2-बाइट मेमोरी पर कब्जा कर लेता है।

सी पॉइंटर घटाव

पॉइंटर जोड़ की तरह, हम पॉइंटर वैरिएबल से एक मान घट सकते हैं। एक सूचक से किसी भी संख्या को घटाने से एक पता मिलेगा। पॉइंटर वैरिएबल से वैल्यू को घटाने का सूत्र नीचे दिया गया है:

DmauRMkktamaee= vaaZmaanaRpataa - (saMqyaa * kaRAakar(deTa pzakar))

32-बिट

32-बिट इंट वैरिएबल के लिए, यह 2 * नंबर को घटाएगा।

64-बिट

64-बिट इंट वैरिएबल के लिए, यह 4 * नंबर को घटाएगा। आइए 64-बिट आर्किटेक्चर पर पॉइंटर चर से मूल्य घटाने का उदाहरण देखें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF(){
paunaZ saMqyaa=50;
paunaZ *pai;//saucak kae paunaZ
pai=&saMqyaa;//BaMdar pataa ka saMqyaa car
mauDznama("pataa ka p car hI %u \n",pai);
pai=pai-3; //oaTanae 3 sae saucak car
mauDznama("baaD oaTanae 3: pataa ka p car hI %u \n",pai);
naivaZtanama 0;
}

आउटपुट

pataa ka pai car hI 3214864300
baaD oaTanae 3: pataa ka pai car hI 3214864288

आप पॉइंटर वैरिएबल से 3 को घटाने के बाद देख सकते हैं, यह पिछले पता मान से 12 (4*3) कम है। हालांकि, एक संख्या को घटाने के बजाय, हम किसी अन्य पते (पॉइंटर) से एक पते को भी घटा सकते हैं। इसके परिणामस्वरूप एक नंबर होगा। यह एक साधारण अंकगणितीय ऑपरेशन नहीं होगा, लेकिन यह निम्नलिखित नियम का पालन करेगा। यदि दो बिंदु एक ही प्रकार के हैं,

.KKtmII2 - .KKtmII1 = (oaTava ka Dae pataaeM)/Aakar ka deTa pzakar kaIna saucak AMk

एक पॉइंटर को दूसरे से घटाने के लिए निम्नलिखित उदाहरण पर विचार करें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
riKta mauqyaF ()
{
paunaZ maIM = 100;
paunaZ *pai = &maIM;
paunaZ *AsYaayai;
AsYaayai = pai;
pai = pai + 3;
mauDznama("saucak oaTava: %paunaZ - %paunaZ = %paunaZ",pai, AsYaayai, pai-AsYaayai);
}

आउटपुट

saucak oaTava: 1030585080 - 1030585068 = 3

पॉइंटर्स के साथ अवैध अंकगणित

ऐसे विभिन्न ऑपरेशन हैं जो पॉइंटर्स पर नहीं किए जा सकते हैं। चूंकि, पॉइंटर स्टोर्स का पता है, इसलिए हमें उन कार्यों को अनदेखा करना चाहिए जो एक अवैध पते को जन्म दे सकते हैं, उदाहरण के लिए, इसके अलावा, और गुणन। इस तरह के संचालन की एक सूची नीचे दी गई है। पता + पता = अवैध पता * पता = अवैध पता % पता = अवैध पता / पता = अवैध पता और पता = अवैध पता ^ पता = अवैध पता | पता = अवैध ~ पता = अवैध

C में कार्य करने के लिए सूचक

जैसा कि हमने पिछले अध्याय में चर्चा की थी, एक पॉइंटर सी में एक फ़ंक्शन को इंगित कर सकता है। हालांकि, पॉइंटर चर की घोषणा फ़ंक्शन के समान होनी चाहिए। फ़ंक्शन की ओर इशारा करते हुए एक सूचक बनाने के लिए निम्नलिखित उदाहरण पर विचार करें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ jaaed.naa ();
paunaZ mauqyaF ()
{
paunaZ parinaama;
paunaZ (*paiTiAar)();
paiTiAar = &jaaed.naa;
parinaama = (*paiTiAar)();
mauDznama(" jaaed. hI %paunaZ",parinaama);
}
paunaZ jaaed.naa()
{
paunaZ P, bai;
mauDznama("pzavaeSa krnaa Dae naMbar?");
saMgazhitaF("%paunaZ %paunaZ",&P,&bai);
naivaZtanama P+bai;
}

आउटपुट

pzavaeSaRkrnaa Dae naMbar?10 15
jaaed. hI 25

सी में कार्यों की सरणी के लिए सूचक

कार्यों की एक सरणी की अवधारणा को समझने के लिए, हमें फ़ंक्शन की सरणी को समझना चाहिए। मूल रूप से, फ़ंक्शन की एक सरणी एक सरणी है जिसमें फ़ंक्शंस के पते होते हैं। दूसरे शब्दों में, कार्यों की एक सरणी के लिए सूचक एक सूचक है जो एक सरणी की ओर इशारा करता है जिसमें कार्यों के लिए संकेत होते हैं। निम्नलिखित उदाहरण पर विचार करें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ DiqaaAae();
paunaZ Saaed(paunaZ);
paunaZ (*Aagamana[3])();
paunaZ (*(*paiTiAar)[3])();

paunaZ mauqyaF ()
{
paunaZ tamaenasaja1;
Aagamana[0] = DiqaaAae;
Aagamana[1] = Saaed;
paiTiAar = &Aagamana;
tamaenasaja1 = (**paiTiAar)();
mauDznama("CpaaEZ kimata laaITa huAa vDara DiqaaAae : %paunaZ",tamaenasaja1);
(*(*paiTiAar+1))(tamaenasaja1);
}
paunaZ DiqaaAae()
{
paunaZ P = 65;
naivaZtanama P++;
}
paunaZ Saaed(paunaZ bai)
{
mauDznama("\naaDiMga 90 kae kimata laaITa huAa vDara DiqaaAae: %paunaZ",bai+90);
}

आउटपुट

CpaaEZ kimata laaITaRhuAa vDara DiqaaAae : 65
jaaed.aRjaaRrhaRhI 90 kae kimata laaITaRhuAa vDara DiqaaAae: 155

bc..mZ kimaataa laaETarhuAa vaidara KpauMMMMMma : 65<baiAar>jaayaDD.Arjarhrhi 90 kaEZ kimaataa laaETarhuAa vaidara KpauMMMMMma: 155<baiAar>